#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
#define int long long

const int N = 500005;
int a[N], ls[N * 30], rs[N * 30], sum[N * 30], root[N];
int n, q, cnt;


int build(int l, int r) {
	int rt = ++cnt;
	if (l == r) {
		sum[rt] = 1;
	}
	else {
		int m = (l + r) >> 1;
		ls[rt] = build(l, m);
		rs[rt] = build(m + 1, r);
		sum[rt] = sum[ls[rt]] + sum[rs[rt]];
	}
	return rt;
}

void solve() {
	cin >> n >> q;
	root[0] = build(1, n);

}

signed main() {
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	solve();
	return 0;
}


//int build(int l, int r) {
//	int rt = ++cnt;
//	if (l == r) {
//		sum[rt] = 1;
//		return rt;
//	}
//	int m = (l + r) >> 1;
//	ls[rt] = build(l, m);
//	rs[rt] = build(m + 1, r);
//	sum[rt] = sum[ls[rt]] + sum[rs[rt]];
//	return rt;
//}
//
//int up(int u ,int jl, int jr,int l,int r) {
//	if (u == 0)return 0;
//	int rt = ++cnt;
//	ls[rt] = ls[u]; rs[rt] = rs[u]; sum[rt] = sum[u];
//	if (jl <= l && r <= jr) {
//		return rt;

//	}
//	int m = (l + r) >> 1;
//	if (jr <= m) {
//		ls[rt] = up(ls[u], jl, jr, l, m);
//	}
//	else if (jl > m) {
//		rs[rt] = up(ls[u], jl, jr, m + 1, r);
//	}
//	else {
//		ls[rt] = up(ls[u], jl, m, l, m);
//		rs[rt] = up(ls[u], m + 1, jr, m + 1, r);
//	}
//	return rt;
//}
//
//int merge(int p, int q, int jl, int jr,int l,int r) {
//	if (!q)return 0;
//	if (jl <= l && r <= jr) {
//		return q;
//	}
//
//	int rt = ++cnt;
//	ls[rt] = ls[p]; rs[rt] = rs[p]; sum[rt] = sum[p];
//
//	int m = (l + r) >> 1;
//	if (jl <= m)ls[rt] = merge(ls[rt], ls[q], jl, jr, l, m);
//	if (jr > m)rs[rt] = merge(rs[rt], rs[q], jl, jr, m + 1, r);
//	sum[rt] = sum[ls[rt]] + sum[rs[rt]];
//	return rt;
//}
//
//int quer(int u, int jl, int jr, int l = 1, int r = n) {
//	if (!u)return 0;
//	if (jl <= l && r <= jr)return sum[u];
//	int m = (l + r) >> 1, ans = 0;
//	if (jl <= m)ans += quer(ls[u], jl, jr, l, m);
//	if (jl > m)ans += quer(rs[u], jl, jr, m + 1, r);
//	return ans;
//}
//
//void solve() {
//	cin >> n >> q;
//	root[0] = build(1, n);
//	for (int i = 1,op, jl, jr, x; i <= q; i++) {
//		cin >> op >> jl >> jr;
//		if (op == 1) {
//			cin >> x;
//			root[x + 1] = merge(root[x + 1], root[x], jl, jr, 1, n);
//		}
//		else {
//			int l = 0, r = n, mid;
//			while (l < r) {
//				mid = (l + r + 1) >> 1;
//				if (quer(root[mid], jl, jr))l = mid;
//				else r = mid - 1;
//			}
//			cout << l << '\n';
//		}
//	}
//}
//
//signed main() {
//	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
//	int t;
//	t = 1;
//	while (t--) {
//		solve();
//	}
//	return 0;
//}
//const int N = 200001;
//int n, m;
//int a[N], sorted[N], root[N], na;
//int ls[N * 30], rs[N * 30], sum[N * 30], cnt;
//
//int build(int l, int r) {
//	int rt = ++cnt;
//	sum[rt] = 0;
//	if (l < r) {
//		int mid = (l + r) >> 1;
//		ls[rt] = build(l, mid);
//		rs[rt] = build(mid + 1, r);
//	}
//	return rt;
//}
//
//int up(int index, int l, int r, int p) {
//	int rt = ++cnt;
//	ls[rt] = ls[p]; rs[rt] = rs[p]; sum[rt] = sum[p];
//	if (l == r) {
//		sum[rt] += 1;
//	}
//	else {
//		int m = (l + r) >> 1;
//		if (index <= m)
//			ls[rt] = up(index, l, m, ls[rt]);
//		else
//			rs[rt] = up(index, m + 1, r, rs[rt]);
//		sum[rt] = sum[ls[rt]] + sum[rs[rt]];
//	}
//	return rt;
//}
//
//int quer(int u, int v, int k, int l, int r) {
//	if (l == r) {
//		return l;
//	}
//	int lsum = sum[ls[v]] - sum[ls[u]];
//	int m = (l + r) >> 1;
//	if (lsum >= k) {
//		return quer(ls[u], ls[v], k, l, m);
//	}
//	else {
//		return quer(rs[u], rs[v], k - lsum, m + 1, r);
//	}
//}
//
//void solve() {
//	cin >> n >> m;
//	for (int i = 1; i <= n; i++) {
//		cin >> a[i];
//		sorted[i] = a[i];
//	}
//
//	sort(sorted + 1, sorted + 1 + n);
//	na = unique(sorted + 1, sorted + 1 + n) - sorted - 1;
//	root[0] = build(1, na);
//
//	for (int i = 1, x; i <= n; i++) {
//		x = lower_bound(sorted + 1, sorted + 1 + na, a[i]) - sorted;
//		root[i] = up(x, 1, na, root[i - 1]);
//	}
//	for (int i = 1, l, r, k; i <= m; i++) {
//		cin >> l >> r >> k;
//		cout << sorted[quer(root[l - 1], root[r], k, 1, na)] << '\n';
//	}
//}
//

//const int N = 200001;
//int n, m;
//int a[N], sorted[N], root[N];
//int ls[N * 30], rs[N * 30], val[N * 30], cnt;
//
//int build(int l, int r) {
//	int rt = ++cnt;
//	if (l == r) {
//		val[rt] = a[l];
//	}
//	else {
//		int mid = (l + r) >> 1;
//		ls[rt] = build(l, mid);
//		rs[rt] = build(mid + 1, r);
//	}
//	return rt;
//}
//
//int up(int index, int jv, int l, int r, int p) {
//	int rt = ++cnt;
//	ls[rt] = ls[p]; rs[rt] = rs[p]; val[rt] = val[p];
//	if (l == r) {
//		val[rt] = jv;
//	}
//	else {
//		int m = (l + r) >> 1;
//		if (index <= m)
//			ls[rt] = up(index, jv, l, m, ls[rt]);
//		else
//			rs[rt] = up(index, jv, m + 1, r, rs[rt]);
//	}
//	return rt;
//}
//
//int quer(int index, int l, int r, int p) {
//	if (l == r) {
//		return val[p];
//	}
//	int m = (l + r) >> 1;
//	if (index <= m)
//		return quer(index, l, m, ls[p]);
//	else
//		return quer(index, m + 1, r, rs[p]);
//}
//
//void solve() {
//	cin >> n >> m;
//	for (int i = 1; i <= n; i++) {
//		cin >> a[i];
//	}
//	root[0] = build(1, n);
//	for (int i = 1, v, op, x, y; i <= m; i++) {
//		cin >> v >> op >> x;
//		if (op == 1) {
//			cin >> y;
//			root[i] = up(x, y, 1, n, root[v]);
//		}
//		else {
//			root[i] = root[v];
//			cout << quer(x, 1, n, root[i]) << '\n';
//		}
//	}
//}
//const int N = 100005;
//int a[N], ida[N], root[N], ls[N << 5], rs[N << 5], sum[N << 5];
//int s, t, k;
//int tot;
//
//int build(int l, int r) {
//	int rt = ++tot;
//	sum[rt] = 0;
//	while (l < r) {
//		int mid = (l + r) >> 1;
//		build(l, mid);
//		build(mid + 1, r);
//	}
//	return rt;
//}
//
//int up(int p, int l, int r, int index) {
//	int rt = ++tot;
//	ls[rt] = ls[p], rs[rt] = rs[p], sum[rt] = sum[p] + 1;
//	if (l < r) {
//		int mid = (l + r) >> 1;
//		if (index <= mid)
//			ls[rt] = up(ls[rt], l, mid, index);
//		else
//			rs[rt] = up(rs[rt], mid + 1, r, index);
//	}
//	return rt;
//}
//
//void solve() {
//
//}
